package cn.fastloader.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

@Slf4j
@Component
public class RedisUtils { 

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 设置缓存
    public boolean set(String key, Object value) { try {
            redisTemplate.opsForValue().set(key, value); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 设置值并设置过期时间（单位秒）
    public boolean set(String key, Object value, long time) { 
        try { if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            } return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 设置一个已经存在的key的值，并返回旧值
    public Object getAndSet(String key, Object value) { 
        try {
            Object andSet = redisTemplate.opsForValue().getAndSet(key, value); return andSet;
        } catch (Exception e) {
            log.error(e.getMessage()); return null;
        }
    } 

    // 如果不存在则设置值value，返回true。 否则返回false
    public boolean setIfAbsent(String key, String value) { 
        try { 
            return redisTemplate.opsForValue().setIfAbsent(key, value);
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 批量设置 k->v 到 redis
    public boolean multiSet(HashMap valueMap) {
        try {
            redisTemplate.opsForValue().multiSet(valueMap); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 如果不存在对应的Map，则批量设置 k->v 到 redis
    public boolean multiSetIfAbsent(HashMap valueMap) { 
        try {
            redisTemplate.opsForValue().multiSetIfAbsent(valueMap); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    }

    // 在原有的值基础上新增字符串到末尾
    public boolean append(String key, String value) { 
        try {
            redisTemplate.opsForValue().append(key, value); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 获取value
    public Object get(String key) { 
        return key == null ? null : redisTemplate.opsForValue().get(key);
    } 

    // 批量获取值
    public List<Object> multiGet(Collection<String> keys) {
        if (CollectionUtils.isEmpty(keys)) {
            return null;
        } 
        return redisTemplate.opsForValue().multiGet(keys);
    } 

    // 删除缓存，支持批量删除
    public void del(String... key) { 
        if (key != null && key.length > 0) { 
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    } 

    // 判断key是否存在
    public boolean hasKey(String key) { 
        try { 
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 根据key 获取key的过期时间
    public long getKeyExpire(String key) { 
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    } 

    // 指定缓存失效时间
    public boolean expireKey(String key, long time) { 
        try { 
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            } return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 通过increment(K key, long increment)方法以增量方式存储long值（正值则自增，负值则自减）
    public void increment(String key, long increment) {
        redisTemplate.opsForValue().increment(key, increment);
    } 

    // 通过increment(K key, double increment)方法以增量方式存储double值（正值则自增，负值则自减）
    public void increment(String key, double increment) {
        redisTemplate.opsForValue().increment(key, increment);
    }

    // 修改redis中key的名称
    public void renameKey(String oldKey, String newKey) {
        redisTemplate.rename(oldKey, newKey);
    } 

    // 如果旧值key存在时，将旧值改为新值
    public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) {
        return redisTemplate.renameIfAbsent(oldKey, newKey);
    }

    // 批量添加Map中的键值对
    public boolean hashPutAll(String mapName, Map<String, String> maps) {
        try {
            redisTemplate.opsForHash().putAll(mapName, maps); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 添加一个键值对
    public boolean hashPutOne(String mapName, String key, String value) { 
        try {
            redisTemplate.opsForHash().put(mapName, key, value); return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    } 

    // 添加一个键值对,仅当hashKey不存在时才设置
    public boolean hashPutOneIfAbsent(String mapName, String hashKey, String value) { 
        try {
            redisTemplate.opsForHash().putIfAbsent(mapName, hashKey, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    }

    // 获取mapName中的所有的键值对
    public Object hashGetOne(String mapName, Object hashKey) { 
        return redisTemplate.opsForHash().get(mapName, hashKey);
    }

    // 获取mapName中的所有的键值对
    public Map<Object, Object> hashGetAll(String mapName) { 
        return redisTemplate.opsForHash().entries(mapName);
    }

    // 删除一个或者多个hash表字段
    public Long hashDelete(String key, Object... fields) { 
        return redisTemplate.opsForHash().delete(key, fields);
    } 

    // 查看hash表中指定字段是否存在
    public boolean hashExists(String key, String field) { 
        return redisTemplate.opsForHash().hasKey(key, field);
    }

    // 给哈希表key中的指定字段的整数值加上增量increment
    public Long hashIncrementByLong(String key, Object field, long increment) { 
        return redisTemplate.opsForHash().increment(key, field, increment);
    }

    // 给哈希表key中的指定字段的double加上增量increment
    public Double hashIncrementByDouble(String key, Object field, double delta) { 
        return redisTemplate.opsForHash().increment(key, field, delta);
    }

    // 获取hash表中存在的所有的key
    public Set<Object> hashKeys(String mapName) { 
        return redisTemplate.opsForHash().keys(mapName);
    }

    // 获取hash表中存在的所有的Value
    public List<Object> hashValues(String mapName) { 
        return redisTemplate.opsForHash().values(mapName);
    }

    // 获取hash表的大小
    public Long hashSize(String mapName) { 
        return redisTemplate.opsForHash().size(mapName);
    }

    // 设置值到List中的头部
    public Boolean listAddInHead(String key, Object value) { 
        try {
            redisTemplate.opsForList().leftPush(key, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    }

    // 批量设置值到List中的头部
    public Boolean listAddAllInHead(String key, Collection<Object> values) { 
        try {
            redisTemplate.opsForList().leftPushAll(key, values); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); return false;
        }
    }

    // 如果存在List->key, 则设置值到List中的头部
    public Boolean listAddIfPresent(String key, Object value) { 
        try {
            redisTemplate.opsForList().leftPushIfPresent(key, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); 
            return false;
        }
    }

    // 设置值到List中的尾部
    public Boolean listAddInEnd(String key, Object value) { 
        try {
            redisTemplate.opsForList().rightPush(key, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage());
            return false;
        }
    }

    // 批量设置值到List中的尾部
    public Boolean listAddAllInEnd(String key, Collection<Object> values) { 
        try {
            redisTemplate.opsForList().rightPushAll(key, values); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); 
            return false;
        }
    }

    // 通过索引去设置List->key中的值
    public Boolean listAddByIndex(String key, long index, Object value) { 
        try {
            redisTemplate.opsForList().set(key, index, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); 
            return false;
        }
    }

    // 根据索引获取list中的值
    public Object listGetByIndex(String key, long index) { 
        return redisTemplate.opsForList().index(key, index);
    } 

    // 根据索引范围获取list中的值
    public List<Object> listGetByRange(String key, long start, long end) { 
        return redisTemplate.opsForList().range(key, start, end);
    }

    // 移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
    public Object listLeftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    // 移除并获取列表中最后一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
    public Object listRightPop(String key) { 
        return redisTemplate.opsForList().rightPop(key);
    }

    // 删除集合中值等于value的元素
    public Long listRemove(String key, long index, Object value) {
        Long removeNum = redisTemplate.opsForList().remove(key, index, value); 
        return removeNum;
    }

    // 设置值到Set集合(支持批量)
    public Boolean setAdd(String key, Object... value) { 
        try {
            redisTemplate.opsForSet().add(key, value); 
            return true;
        } catch (Exception e) {
            log.error(e.getMessage()); 
            return false;
        }
    } 

    // 移除Set集合中的值，支持批量
    public long setRemove(String key, Object... values) { 
        return redisTemplate.opsForSet().remove(key, values);
    }

    // 判断Set中是否存在value
    public boolean setIsExist(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }


}